home *** CD-ROM | disk | FTP | other *** search
/ Carousel / CAROUSEL.cdr / mactosh / code / p_serlib.sit / Serial Library Source Code / serial.writeFile.dll.c < prev    next >
C/C++ Source or Header  |  1989-07-27  |  9KB  |  319 lines
  1. /***********************************************************************/
  2. /*    
  3. /*    serial.writeFile.dll.c
  4. /*    by Atul Butte
  5. /*    Copyright ⌐ 1989 by Microsoft Corporation
  6. /*    All Rights Reserved
  7. /*
  8. /*    version 1.0
  9. /*    
  10. /*    
  11. /*    This CALL/REGISTER will send a text file through a serial port.
  12. /*    
  13. /*    Excel usage:
  14. /*    
  15. /*    = Register( "serial library", "serial.writeFile", "IHCD" )
  16. /*    = Call( ref, portNumber, writeConfigStr, fileName )
  17. /*    
  18. /*    where
  19. /*        portNumber        = number of port (1 = modem, 2 = printer)
  20. /*        writeConfigStr    = configuration of communications protocol, etc
  21. /*        fileName        = name of text file to send
  22. /*    
  23. /***********************************************************************/
  24.  
  25. /***********************************************************************/
  26. /*
  27. /*    D E F I N E S
  28. /*
  29. /***********************************************************************/
  30.  
  31. #define ROUTINE_NAME        "serial.writeFile"
  32. #define hNIL 0L
  33. #define pNIL 0L
  34. #define kcchBuff 64
  35.  
  36. /***********************************************************************/
  37. /*
  38. /*    I N C L U D E S
  39. /*
  40. /***********************************************************************/
  41.  
  42. #include "serial.h"
  43. #include "error.h"
  44. #include "get_port.h"
  45. #include "absorb_echo.h"
  46. #include "get_write_flags.h"
  47.  
  48. /***********************************************************************/
  49. /*
  50. /*    P R O T O T Y P E S
  51. /*
  52. /***********************************************************************/
  53.  
  54. short open_file( char *pstFilename );
  55. void close_file( short refFile, char *pch );
  56. OSErr get_character( short refFile, char *pch, char *pchBuff, unsigned short *puichBuff );
  57.  
  58. /***********************************************************************/
  59. /*
  60. /*    main
  61. /*
  62. /***********************************************************************/
  63.  
  64. pascal short main( port, pszConfig, pstFilename )
  65.  
  66.     unsigned short            port;                    /* serial port to use */
  67.     register char            *pszConfig;                /* communications configuration string */
  68.     register char            *pstFilename;            /* name of text file to send */
  69.     
  70. {
  71.     register OSErr            err;                    /* result code from Toolbox routines */
  72.     ParamBlockRec            param;                    /* parameter block for read/write */
  73.     
  74.     Boolean                    fAddLF = false;            /* flag for adding linefeeds */
  75.     Boolean                    fIgnore = false;        /* flag for ignoring escape chars */
  76.     Boolean                    fStrip8Bit = false;        /* flag for stripping high bit */
  77.     Boolean                    fAbsorbEcho = false;    /* flag for waiting for echo from host */
  78.     
  79.     short                    refIn;                    /* reference number for input port */
  80.     short                    refOut;                    /* reference number for output port */
  81.     register long            ich;                    /* index in characters to send (# already sent) */
  82.     long                    cch;                    /* count of total characters to send */
  83.     long                    cchBuff = 0;            /* number of characters waiting in read buffer */
  84.     char                    ch;                        /* character to write */
  85.     
  86.     char                    *pch;                    /* buffer used in file reading */
  87.     unsigned short            ichBuff = 0;            /* index in buffer */
  88.     short                    refFile;                /* reference number for file */
  89.     
  90.     RememberA0();
  91.     SetUpA4();
  92.     if( pszConfig == pNIL ) {
  93.         display_error( "The second parameter must be a configuration string." );
  94.         RestoreA4( );
  95.         return( errParam );
  96.     }
  97.     if( pstFilename == pNIL ) {
  98.         display_error( "The third parameter must be a file name." );
  99.         RestoreA4( );
  100.         return( errParam );
  101.     }
  102.     if( *pstFilename == 0 ) {
  103.         display_error( "The third parameter must be a file name." );
  104.         RestoreA4( );
  105.         return( errParam );
  106.     }
  107.     
  108.     err = get_port( port, &refIn, &refOut );
  109.     if( err != noErr ) {
  110.         display_error( "Illegal port number." );
  111.         RestoreA4( );
  112.         return( err );
  113.     }
  114.     
  115.     pch = NewPtr( kcchBuff );
  116.     if( pch == pNIL ) {
  117.         display_error( "Not enough memory to allocate buffer." );
  118.         RestoreA4( );
  119.         return( errMemory );
  120.     }
  121.     ichBuff = 0;
  122.     
  123.     if( ( refFile = open_file( pstFilename ) ) == 0 ) {
  124.         RestoreA4( );
  125.         return( errDiskRead );
  126.     }
  127.     
  128.     get_write_flags( pszConfig, &fAddLF, &fIgnore, &fStrip8Bit, &fAbsorbEcho );
  129.     
  130.     if( fAbsorbEcho ) {            /* flush input buffer */
  131.         do {
  132.             err = SerGetBuf( refIn, &cchBuff );
  133.             if( err != noErr ) {
  134.                 display_error( "Error trying to count buffer." );
  135.                 break;
  136.             }
  137.             if( cchBuff != 0 ) {
  138.                 param.ioParam.ioReqCount = 1;
  139.                 param.ioParam.ioBuffer = &ch;
  140.                 param.ioParam.ioRefNum = refIn;
  141.                 err = PBRead( ¶m, false );
  142.                 if( err != noErr ) {
  143.                     display_error( "Error trying to flush the input buffer." );
  144.                     return( errSerialRead );
  145.                 }
  146.             }
  147.         } while( cchBuff != 0 );
  148.     }
  149.     
  150.     ich = 0;
  151.     err = GetEOF( refFile, &cch );
  152.     if( err != noErr ) {
  153.         display_error( "Error in finding end of file." );
  154.         close_file( refFile, pch );
  155.         RestoreA4( );
  156.         return( errDiskRead );
  157.     }
  158.     
  159.     while( ich < cch ) {
  160.         
  161.         err = get_character( refFile, &ch, pch, &ichBuff );
  162.         if( err != noErr ) {
  163.             close_file( refFile, pch );
  164.             RestoreA4( );
  165.             return( err );
  166.         }
  167.         
  168.         if( fStrip8Bit ) {
  169.             ch &= 0x7f;
  170.         }
  171.         
  172.         param.ioParam.ioReqCount = 1;
  173.         param.ioParam.ioBuffer = &ch;
  174.         param.ioParam.ioRefNum = refOut;
  175.         err = PBWrite( ¶m, false );
  176.         if( err != noErr ) {
  177.             display_error( "Error writing to serial port." );
  178.             close_file( refFile, pch );
  179.             RestoreA4();
  180.             return( errSerialWrite );
  181.         }
  182.         
  183.         if( fAbsorbEcho ) {
  184.             if( absorb_echo( refIn, ch ) != noErr ) {
  185.                 display_error( "Error reading echo from serial port." );
  186.                 close_file( refFile, pch );
  187.                 RestoreA4();
  188.                 return( errSerialWrite );
  189.             }
  190.         }
  191.         
  192.         if( (ch == kchReturn) && (fAddLF) ) {
  193.             ch = kchLinefeed;
  194.             param.ioParam.ioReqCount = 1;
  195.             param.ioParam.ioBuffer = &ch;
  196.             param.ioParam.ioRefNum = refOut;
  197.             err = PBWrite( ¶m, false );
  198.             if( err != noErr ) {
  199.                 display_error( "Error writing linefeed to serial port." );
  200.                 close_file( refFile, pch );
  201.                 RestoreA4();
  202.                 return( errSerialWrite );
  203.             }
  204.             
  205.             if( fAbsorbEcho ) {
  206.                 if( absorb_echo( refIn, ch ) != noErr ) {
  207.                     display_error( "Error reading echo from serial port." );
  208.                     close_file( refFile, pch );
  209.                     RestoreA4();
  210.                     return( errSerialWrite );
  211.                 }
  212.             }
  213.         }
  214.         ich++;
  215.     }
  216.     close_file( refFile, pch );
  217.     RestoreA4();
  218.     return( noErr );
  219. }
  220.  
  221. /***********************************************************************/
  222. /*
  223. /*    open_file
  224. /*
  225. /***********************************************************************/
  226.  
  227. short open_file( pstFilename )
  228.  
  229.     char                    *pstFilename;            /* name of text file to send */
  230.     
  231. {
  232.     short                    refFile;                /* reference number for file */
  233.     OSErr                    err;                    /* result code from Toolbox routines */
  234.     ParamBlockRec            param;                    /* parameter block for read/write */
  235.         
  236.     param.ioParam.ioNamePtr = (StringPtr) pstFilename;
  237.     param.ioParam.ioVRefNum = 0;
  238.     param.ioParam.ioPermssn = fsRdPerm;
  239.     param.ioParam.ioMisc = 0;
  240.     err = PBOpen( ¶m, false );
  241.     refFile = param.ioParam.ioRefNum;
  242.     if( err == fnfErr ) {
  243.         display_error( "File not found." );
  244.         return( 0 );
  245.     } else if( err != noErr ) {
  246.         display_error( "Error in reading file." );
  247.         return( 0 );
  248.     }
  249.     err = SetFPos( refFile, fsFromStart, 0L );
  250.     if( err != noErr ) {
  251.         display_error( "Error in setting mark to beginning of file." );
  252.         FSClose( refFile );
  253.         return( 0 );
  254.     }
  255.     return( refFile );
  256. }
  257.  
  258. /***********************************************************************/
  259. /*
  260. /*    close_file
  261. /*
  262. /***********************************************************************/
  263.  
  264. void close_file( refFile, pch )
  265.  
  266.     short                    refFile;                /* reference number for file */
  267.     char                    *pch;                    /* buffer used in file reading */
  268.     
  269. {
  270.     OSErr                    err;                    /* result code from Toolbox routines */
  271.     
  272.     err = FSClose( refFile );
  273.     if( err != noErr ) {
  274.         display_error( "Error closing file." );
  275.     }
  276.     
  277.     DisposPtr( pch );
  278. }
  279.  
  280. /***********************************************************************/
  281. /*
  282. /*    get_character
  283. /*
  284. /***********************************************************************/
  285.  
  286. OSErr get_character( refFile, pch, pchBuff, puichBuff )
  287.  
  288.     short                    refFile;                /* reference number for file */
  289.     char                    *pch;                    /* character to get from file */
  290.     char                    *pchBuff;                /* buffer used in file reading */
  291.     unsigned short            *puichBuff;                /* index in our file buffer */
  292.     
  293. {
  294.     OSErr                    err;                    /* result code from Toolbox routines */
  295.     long                    cch;                    /* count of characters to read */
  296.     
  297.     if( *puichBuff >= kcchBuff )                    /* if we have read the whole buffer */
  298.         *puichBuff = 0;
  299.     if( *puichBuff > 0 ) {                            /* if there are chars left in the buffer */
  300.         *pch = pchBuff[*puichBuff];
  301.         ( *puichBuff )++;
  302.     } else {                                        /* otherwise */
  303.         cch = kcchBuff;
  304.         err = FSRead( refFile, &cch, pchBuff );                /* read in a bunch more */
  305.         if( (err == eofErr) || (err == noErr) ) {
  306.             *puichBuff = 1;
  307.             *pch = *pchBuff;
  308.         } else {
  309.             display_error( "Error in reading from file." );
  310.             return( errDiskRead );
  311.         }
  312.     }
  313.     return( noErr );
  314. }
  315.  
  316. #include "get_write_flags.c"
  317. #include "get_port.c"
  318. #include "absorb_echo.c"
  319.